public final class cls_g {

    private int a[];
    private int b[];
    private int c[];
    private int d[];
    private int e[];
    private byte f[];
    private long g;
    private int h;
    private int i;
    private static int j;

    public cls_g(String s) {
        a = new int[18];
        b = new int[256];
        c = new int[256];
        d = new int[256];
        e = new int[256];
        f = new byte[8];
        int k = s.getBytes().length;
//        s = 0;
        byte abyte0[] = s.getBytes();
//        s = this;
        g = 0x5deef535dL;
        this.b();
        this.a(abyte0, 0, k);
    }

    private void a(byte abyte0[], int k, int l) {
        if (l == 0)
            return;
        int i1 = 0;
        int j1 = k;
        l = k + l;
        for (int k1 = 0; k1 < 18; k1++) {
            for (int j3 = 0; j3 < 4; j3++) {
                i1 = i1 << 8 | abyte0[k] & 0xff;
                if (++k == l)
                    k = j1;
            }

            a[k1] ^= i1;
        }

        for (int l1 = 0; l1 < 8; l1++)
            f[l1] = 0;

        for (int i2 = 0; i2 < 18;) {
            a(f, 0, f, 0, 8);
            a[i2++] = a(f, 0);
            a[i2++] = a(f, 4);
        }

        for (int j2 = 0; j2 < 256;) {
            a(f, 0, f, 0, 8);
            b[j2++] = a(f, 0);
            b[j2++] = a(f, 4);
        }

        for (int k2 = 0; k2 < 256;) {
            a(f, 0, f, 0, 8);
            c[k2++] = a(f, 0);
            c[k2++] = a(f, 4);
        }

        for (int l2 = 0; l2 < 256;) {
            a(f, 0, f, 0, 8);
            d[l2++] = a(f, 0);
            d[l2++] = a(f, 4);
        }

        for (int i3 = 0; i3 < 256;) {
            a(f, 0, f, 0, 8);
            e[i3++] = a(f, 0);
            e[i3++] = a(f, 4);
        }

    }

    private int a(byte abyte0[], int k, byte abyte1[], int l, int i1) {
        int[] bl;
        i1 = (bl = a)[0];
        int j1 = bl[1];
        int k1 = bl[2];
        int l1 = bl[3];
        int i2 = bl[4];
        int j2 = bl[5];
        int k2 = bl[6];
        int l2 = bl[7];
        int i3 = bl[8];
        int j3 = bl[9];
        int k3 = bl[10];
        int l3 = bl[11];
        int i4 = bl[12];
        int j4 = bl[13];
        int k4 = bl[14];
        int l4 = bl[15];
        int i5 = bl[16];
        l = bl[17];
        int ai[] = b;
        int ai1[] = c;
        int ai2[] = d;
        int ai3[] = e;
        while (k < 8) {
            int j5;
            k++;
            k++;
            k++;
            k++;
            j5 = (((abyte0[0] << 24) | abyte0[1] << 16 & 0xff0000) | abyte0[2] << 8 & 0xff00) | abyte0[3] & 0xff;
            int k5;
            k++;
            k++;
            k++;
            k++;
            k5 = (((abyte0[4] << 24) | abyte0[5] << 16 & 0xff0000) | abyte0[6] << 8 & 0xff00) | abyte0[7] & 0xff;
            j5 ^= i1;
            k5 ^= (ai[j5 >>> 24] + ai1[j5 >>> 16 & 0xff] ^ ai2[j5 >>> 8 & 0xff]) + ai3[j5 & 0xff] ^ j1;
            j5 ^= (ai[k5 >>> 24] + ai1[k5 >>> 16 & 0xff] ^ ai2[k5 >>> 8 & 0xff]) + ai3[k5 & 0xff] ^ k1;
            k5 ^= (ai[j5 >>> 24] + ai1[j5 >>> 16 & 0xff] ^ ai2[j5 >>> 8 & 0xff]) + ai3[j5 & 0xff] ^ l1;
            j5 ^= (ai[k5 >>> 24] + ai1[k5 >>> 16 & 0xff] ^ ai2[k5 >>> 8 & 0xff]) + ai3[k5 & 0xff] ^ i2;
            k5 ^= (ai[j5 >>> 24] + ai1[j5 >>> 16 & 0xff] ^ ai2[j5 >>> 8 & 0xff]) + ai3[j5 & 0xff] ^ j2;
            j5 ^= (ai[k5 >>> 24] + ai1[k5 >>> 16 & 0xff] ^ ai2[k5 >>> 8 & 0xff]) + ai3[k5 & 0xff] ^ k2;
            k5 ^= (ai[j5 >>> 24] + ai1[j5 >>> 16 & 0xff] ^ ai2[j5 >>> 8 & 0xff]) + ai3[j5 & 0xff] ^ l2;
            j5 ^= (ai[k5 >>> 24] + ai1[k5 >>> 16 & 0xff] ^ ai2[k5 >>> 8 & 0xff]) + ai3[k5 & 0xff] ^ i3;
            k5 ^= (ai[j5 >>> 24] + ai1[j5 >>> 16 & 0xff] ^ ai2[j5 >>> 8 & 0xff]) + ai3[j5 & 0xff] ^ j3;
            j5 ^= (ai[k5 >>> 24] + ai1[k5 >>> 16 & 0xff] ^ ai2[k5 >>> 8 & 0xff]) + ai3[k5 & 0xff] ^ k3;
            k5 ^= (ai[j5 >>> 24] + ai1[j5 >>> 16 & 0xff] ^ ai2[j5 >>> 8 & 0xff]) + ai3[j5 & 0xff] ^ l3;
            j5 ^= (ai[k5 >>> 24] + ai1[k5 >>> 16 & 0xff] ^ ai2[k5 >>> 8 & 0xff]) + ai3[k5 & 0xff] ^ i4;
            k5 ^= (ai[j5 >>> 24] + ai1[j5 >>> 16 & 0xff] ^ ai2[j5 >>> 8 & 0xff]) + ai3[j5 & 0xff] ^ j4;
            j5 ^= (ai[k5 >>> 24] + ai1[k5 >>> 16 & 0xff] ^ ai2[k5 >>> 8 & 0xff]) + ai3[k5 & 0xff] ^ k4;
            k5 ^= (ai[j5 >>> 24] + ai1[j5 >>> 16 & 0xff] ^ ai2[j5 >>> 8 & 0xff]) + ai3[j5 & 0xff] ^ l4;
            j5 ^= (ai[k5 >>> 24] + ai1[k5 >>> 16 & 0xff] ^ ai2[k5 >>> 8 & 0xff]) + ai3[k5 & 0xff] ^ i5;
            k5 ^= l;
            abyte1[0] = (byte) (k5 >> 24);
            abyte1[1] = (byte) (k5 >>> 16);
            abyte1[2] = (byte) (k5 >>> 8);
            abyte1[3] = (byte) k5;
            abyte1[4] = (byte) (j5 >> 24);
            abyte1[5] = (byte) (j5 >>> 16);
            abyte1[6] = (byte) (j5 >>> 8);
            abyte1[7] = (byte) j5;
        }
        return 8;
    }

    private static final int a(byte abyte0[], int k) {
        return abyte0[k] << 24 | (abyte0[k + 1] & 0xff) << 16 | (abyte0[k + 2] & 0xff) << 8 | abyte0[k + 3] & 0xff;
    }

    private synchronized int a() {
        g = g * 0x5deece66dL + 11L & 0xffffffffffffL;
        return (int) (g >>> 16);
    }

    private void b() {
        for (int k = 0; k < a.length; k++)
            a[k] = a();

        for (int l = 0; l < b.length; l++) {
            b[l] = a();
            c[l] = a();
            d[l] = a();
            e[l] = a();
        }

    }

    private static int a(int k) {
        int l;
        if ((l = k % 8) == 0)
            return k;
        else
            return (k - l) + 8;
    }

    public static String a(byte abyte0[]) {
        int k = abyte0.length;
        StringBuffer stringbuffer = new StringBuffer(k);
        for (int l = 0; l < k; l++) {
            int i1;
            if ((i1 = abyte0[l] & 0xff) < 16)
                stringbuffer.append("0" + Integer.toHexString(i1).toString());
            else
                stringbuffer.append(Integer.toHexString(i1));
        }

        return stringbuffer.toString();
    }

    public final byte[] a(String s) {
        cls_g g1 = this;
        (g1).i = g1.h = 0;
        byte abyte0[] = new byte[a(s.getBytes().length)];
        byte[] as = s.getBytes();
        byte abyte1[] = new byte[a(as.length)];
        for (int k = 0; k < abyte0.length; k++)
            if (k < as.length)
                abyte0[k] = as[k];
            else
                abyte0[k] = 0;

        int j1 = abyte0.length;
        int i1 = 0;
        byte abyte2[] = abyte1;
        int l = 0;
        as = abyte0;
//        abyte0 = this;
        j1 -= j1 % 8;
        j1 += 0;
        int ai[];
        int l1 = (ai = a)[0];
        int i2 = ai[1];
        int j2 = ai[2];
        int k2 = ai[3];
        int l2 = ai[4];
        int i3 = ai[5];
        int j3 = ai[6];
        int k3 = ai[7];
        int l3 = ai[8];
        int i4 = ai[9];
        int j4 = ai[10];
        int k4 = ai[11];
        int l4 = ai[12];
        int i5 = ai[13];
        int j5 = ai[14];
        int k5 = ai[15];
        int l5 = ai[16];
        int k1 = ai[17];
        int ai1[] = b;
        int ai2[] = c;
        int ai3[] = d;
        int ai4[] = e;
        int i6 = i;
        int j6;
        int k6;
        for (j6 = h; l < j1; j6 = k6) {
            k6 = (((as[l++] << 24) | as[l++] << 16 & 0xff0000) | as[l++] << 8 & 0xff00) | as[l++] & 0xff;
            int l6;
            l6 = (((as[l++] << 24) | as[l++] << 16 & 0xff0000) | as[l++] << 8 & 0xff00) | as[l++] & 0xff;
            k6 ^= i6;
            l6 ^= j6;
            k6 ^= l1;
            l6 ^= (ai1[k6 >>> 24] + ai2[k6 >>> 16 & 0xff] ^ ai3[k6 >>> 8 & 0xff]) + ai4[k6 & 0xff] ^ i2;
            k6 ^= (ai1[l6 >>> 24] + ai2[l6 >>> 16 & 0xff] ^ ai3[l6 >>> 8 & 0xff]) + ai4[l6 & 0xff] ^ j2;
            l6 ^= (ai1[k6 >>> 24] + ai2[k6 >>> 16 & 0xff] ^ ai3[k6 >>> 8 & 0xff]) + ai4[k6 & 0xff] ^ k2;
            k6 ^= (ai1[l6 >>> 24] + ai2[l6 >>> 16 & 0xff] ^ ai3[l6 >>> 8 & 0xff]) + ai4[l6 & 0xff] ^ l2;
            l6 ^= (ai1[k6 >>> 24] + ai2[k6 >>> 16 & 0xff] ^ ai3[k6 >>> 8 & 0xff]) + ai4[k6 & 0xff] ^ i3;
            k6 ^= (ai1[l6 >>> 24] + ai2[l6 >>> 16 & 0xff] ^ ai3[l6 >>> 8 & 0xff]) + ai4[l6 & 0xff] ^ j3;
            l6 ^= (ai1[k6 >>> 24] + ai2[k6 >>> 16 & 0xff] ^ ai3[k6 >>> 8 & 0xff]) + ai4[k6 & 0xff] ^ k3;
            k6 ^= (ai1[l6 >>> 24] + ai2[l6 >>> 16 & 0xff] ^ ai3[l6 >>> 8 & 0xff]) + ai4[l6 & 0xff] ^ l3;
            l6 ^= (ai1[k6 >>> 24] + ai2[k6 >>> 16 & 0xff] ^ ai3[k6 >>> 8 & 0xff]) + ai4[k6 & 0xff] ^ i4;
            k6 ^= (ai1[l6 >>> 24] + ai2[l6 >>> 16 & 0xff] ^ ai3[l6 >>> 8 & 0xff]) + ai4[l6 & 0xff] ^ j4;
            l6 ^= (ai1[k6 >>> 24] + ai2[k6 >>> 16 & 0xff] ^ ai3[k6 >>> 8 & 0xff]) + ai4[k6 & 0xff] ^ k4;
            k6 ^= (ai1[l6 >>> 24] + ai2[l6 >>> 16 & 0xff] ^ ai3[l6 >>> 8 & 0xff]) + ai4[l6 & 0xff] ^ l4;
            l6 ^= (ai1[k6 >>> 24] + ai2[k6 >>> 16 & 0xff] ^ ai3[k6 >>> 8 & 0xff]) + ai4[k6 & 0xff] ^ i5;
            k6 ^= (ai1[l6 >>> 24] + ai2[l6 >>> 16 & 0xff] ^ ai3[l6 >>> 8 & 0xff]) + ai4[l6 & 0xff] ^ j5;
            l6 ^= (ai1[k6 >>> 24] + ai2[k6 >>> 16 & 0xff] ^ ai3[k6 >>> 8 & 0xff]) + ai4[k6 & 0xff] ^ k5;
            k6 ^= (ai1[l6 >>> 24] + ai2[l6 >>> 16 & 0xff] ^ ai3[l6 >>> 8 & 0xff]) + ai4[l6 & 0xff] ^ l5;
            l6 ^= k1;
            abyte2[i1++] = (byte) (l6 >> 24);
            abyte2[i1++] = (byte) (l6 >>> 16);
            abyte2[i1++] = (byte) (l6 >>> 8);
            abyte2[i1++] = (byte) l6;
            abyte2[i1++] = (byte) (k6 >> 24);
            abyte2[i1++] = (byte) (k6 >>> 16);
            abyte2[i1++] = (byte) (k6 >>> 8);
            abyte2[i1++] = (byte) k6;
            i6 = l6;
        }

        this.i = i6;
        this.h = j6;
        return abyte1;
    }

    public final String a(byte abyte0[], String s) {
        abyte0 = a(s);
        int is;
        for (is = 0; is < abyte0.length; is++) {
            int k = j >>> 8 & 0xffffff;
            int l;
            l = (j ^ abyte0[is]) & 0xff;
            for (int i1 = 8; i1 > 0; i1--)
                if ((l & 1) == 1)
                    l = l >>> 1 ^ 0xedb88320;
                else
                    l >>>= 1;

//            l = l;
            j = k ^ l;
        }

        is = j;
        j = 0;
        return Integer.toHexString(is);
    }
}